package huawei;

import java.util.*;

/**
 * 机器人的活动区域
 */
public class RobotMaxActivityArea {

//    // 查找集群的根节点（带路径压缩）
//    public static int find(int x, int[] f) {
//        // 如果当前节点不是根节点，则递归找到根节点并进行路径压缩
//        while (x != f[x]) {
//            f[x] = f[f[x]]; // 路径压缩：让当前节点直接指向其祖先节点
//            x = f[x];
//        }
//        return x; // 返回根节点
//    }
//
//    // 合并两个集群
//    public static void merge(int x, int y, int[] f, int[] sz) {
//        int fx = find(x, f); // 找到 x 的根节点
//        int fy = find(y, f); // 找到 y 的根节点
//        if (fx != fy) { // 如果两个节点不属于同一个集群
//            sz[fy] += sz[fx]; // 合并两个集群的大小
//            f[fx] = fy;       // 将 x 的根节点连接到 y 的根节点
//        }
//    }
//
//    public static void solve() {
//        Scanner scanner = new Scanner(System.in);
//
//        // 输入矩阵的行数和列数
//        int n = scanner.nextInt();
//        int m = scanner.nextInt();
//
//        // 初始化矩阵
//        int[][] a = new int[n][m];
//        for (int i = 0; i < n; i++) {
//            for (int j = 0; j < m; j++) {
//                a[i][j] = scanner.nextInt(); // 输入每个矩阵元素
//            }
//        }
//
//        // 并查集的父节点数组和集群大小数组
//        int[] f = new int[n * m]; // 并查集父节点数组
//        int[] sz = new int[n * m]; // 集群大小数组，初始大小为 1
//        for (int i = 0; i < n * m; i++) {
//            f[i] = i;  // 每个位置的父节点初始化为自身
//            sz[i] = 1; // 每个集群的初始大小为 1
//        }
//
//        // 方向数组，表示四个方向：上、下、左、右
//        int[][] offsets = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
//
//        // 遍历矩阵中的每个元素
//        for (int i = 0; i < n; i++) {
//            for (int j = 0; j < m; j++) {
//                // 尝试向四个方向移动
//                for (int[] offset : offsets) {
//                    int newI = i + offset[0]; // 新行坐标
//                    int newJ = j + offset[1]; // 新列坐标
//
//                    // 检查是否越界，并且相邻元素的差值是否 <= 1
//                    if (newI >= 0 && newI < n && newJ >= 0 && newJ < m && Math.abs(a[i][j] - a[newI][newJ]) <= 1) {
//                        // 将 (i, j) 和 (newI, newJ) 合并到同一个集群
//                        merge(i * m + j, newI * m + newJ, f, sz);
//                    }
//                }
//            }
//        }
//
//        // 初始化答案为 1，即最大集群大小
//        int ans = 1;
//
//        // 遍历所有的节点，查找每个节点的集群，并更新最大集群大小
//        for (int i = 0; i < n * m; i++) {
//            ans = Math.max(ans, sz[find(i, f)]); // 更新答案
//        }
//
//        // 输出最大集群的大小
//        System.out.println(ans);
//    }
//
//    public static void main(String[] args) {
//        solve(); // 调用 solve 函数解决问题
//    }

    public static void main(String[] args) {
//        int [][] rods = new int[][]{
//                {1, 2, 5, 2},
//                {2, 4, 4, 5},
//                {3, 5, 7, 1},
//                {4, 6, 2, 4}
//        };

        int [][] rods = new int[][]{
                {1,3,5},
                {4, 1, 3}
        };

        int[][] pos = new int[rods.length][rods[0].length];

        int max = 0;
        for (int i = 0; i < rods.length; i++) {
            for (int j = 0; j < rods[0].length; j++) {
                max = Math.max(find(rods, pos, i, j), max);
            }
        }
        System.out.println(max);
    }

    static int[][] direction = {{-1, 0}, {1, 0},{0, -1}, {0, 1}}; // 方向

    public static int find(int[][] roads, int[][] pos, int i, int j) {
        if (pos[i][j] == 1) return 0;
        pos[i][j] = 1;
        int sum = 1;

        for (int[] d : direction) {
            int x = i + d[0];
            int y = j + d[1];

            if (x >= 0 && y >= 0 && x < roads.length && y < roads[0].length && pos[x][y] == 0 && Math.abs(roads[x][y] - roads[i][j]) <= 1) {
                sum += find(roads, pos, x, y);
                pos[x][y] = 1;
            }
        }

        return sum;
    }
}
